I think this won't work if there are multiple unstable_feature_bound attributes. E.g.

#[unstable_feature_bound(feat_foo)]
#[unstable_feature_bound(feat_bar)]
#[unstable(feature = "feat_bar", issue = "none")]
impl Foo for Bar {}

you should be able to do something like:
find_attr!(attrs, AttributeKind::AllowUnstableFeature(i) if i == feature)
to get a yes/no as to whether there's an unstable feature bound on the impl with the same symbol as the stability attr

This reminds me, I am not sure if I handled multiple attributes case correctly in compiler/rustc_hir_analysis/src/collect/predicates_of.rs. I will take a look at that too.

oh, yes, I don't think that's correct either

I did a bit of tracing, and found this surprisingly works,

I tested with

#[unstable_feature_bound(feat_bar, feat_koo)]
#[unstable_feature_bound(feat_foo, feat_moo)]
#[unstable(feature = "feat_bar", issue = "none")]
impl Foo for Bar {
}

and it got every symbols on unstable_feature_bound

According to the trace, I suspect the two #[unstable_feature_bound] are parsed as one in attrs?

annotate(id = DefId(0:6 ~ unstable_feature_bound_attr_test[4947]::{impl#0}),
 attrs = [Parsed(Stability { 
 stability: Stability { level: Unstable { reason: None, issue: None, is_soft: false, implied_by: None, old_name: None }, feature: "feat_bar" }, 
 span: tests/ui/unstable-feature_bound/unstable_feature_bound_attr_test.rs:16:1: 16:50 (#0) }), 
 
 Parsed(UnstableFeatureBound([("feat_bar", 
 tests/ui/unstable-feature_bound/unstable_feature_bound_attr_test.rs:14:1: 14:46 (#0)), 
 ("feat_koo", tests/ui/unstable-feature_bound/unstable_feature_bound_attr_test.rs:14:1: 14:46 (#0)), 
 ("feat_foo", tests/ui/unstable-feature_bound/unstable_feature_bound_attr_test.rs:15:1: 15:46 (#0)), 
 ("feat_moo", tests/ui/unstable-feature_bound/unstable_feature_bound_attr_test.rs:15:1: 15:46 (#0))]))])

Added a test for this tests/ui/unstable-feature_bound/unstable_feature_bound_multi_attr.rs

I tweaked the comment by a little bit

        // We don't consider feature bounds to hold in the crate when `staged_api` feature is
        // enabled, even if it is enabled through `#[feature]`. 
        // This is to prevent accidentally leaking unstable APIs to stable.

hope this captured what you intended to say :D

I tried to use feature_bound_holds_in_crate in the old solver, just like what is done in the new solver, but it requires rustc_type_ir::inherent::*, and has scary message

error: do not use `rustc_type_ir::inherent` unless you're inside of the trait solver
  --> compiler/rustc_trait_selection/src/traits/fulfill.rs:15:20
   |
15 | use rustc_type_ir::inherent::*;
   |                    ^^^^^^^^
   |
   = note: the method or struct you're looking for is likely defined somewhere else downstream in the compiler
   = note: `-D rustc::usage-of-type-ir-inherent` implied by `-D warnings`
   = help: to override `-D warnings` add `#[allow(rustc::usage_of_type_ir_inherent)]`

so i decided to just write it out manually :)

Do we want to change the error message to unstable_feature_bound may not be used outside of the standard library or it is acceptable to call it stability attribute?